13. Aspect Oriented Programming (AOP)

Aspect Oriented Programming (AOP)

In this lesson, you'll learn the basic concepts of AOP, and we'll cover how AOP frameworks use dynamic proxies and dependency injection.

What is Aspect Oriented Programming?

Aspect Oriented Programming (AOP) is a design pattern that organizes code into cross-cutting concerns.

• A cross-cutting concern is any concern that affects many different parts of the system. Examples include: logging, performance profiling, and database transaction managements.
• All the code that handles a cross-cutting concern is organized into an aspect, which is subdivided into advice.
• Advice plugs into your executing code, via a method interceptor, to take care of the cross-cutting concern.
• Join points are places where advice can plug into your code, usually via method interceptors.
• Whereas a join point is a place where your code could potentially use advice, pointcuts are places where your code actually does use advice. An aspect is defined by advice and one or more pointcuts.

QUIZ QUESTION::

Match each AOP concept to its description.

ANSWER CHOICES:

A Join Point where advice is applied in a program.

All the code that handles a cross-cutting concern.

Any concern that affects many different parts of the system.

Code execution locations where advice can be applied.

Addresses a cross-cutting concern via a pointcut, usually with a method interceptor.

AOP Concept	Description
Cross-cutting concern
Aspect
Advice
Join Point
Pointcut

SOLUTION:

AOP Concept	Description
Pointcut	A Join Point where advice is applied in a program.
Aspect	All the code that handles a cross-cutting concern.
Cross-cutting concern	Any concern that affects many different parts of the system.
Join Point	Code execution locations where advice can be applied.
Advice	Addresses a cross-cutting concern via a pointcut, usually with a method interceptor.

How AOP Uses Dynamic Proxies and Dependency Injection

• AOP uses dynamic proxies to intercept methods and execute advice.

• When you add an @Inject annotation to your code, the AOP framework uses dependency injection to supply an object. The supplied object is actually a dynamic proxy with method interceptors to run different pieces of advice code.

Join Points are locations where an aspect can plug into program execution. Which of the following options are common Join Points?

Instance method invocations

Static method invocations

Object creation

Object destruction

Program startup

Program termination

SOLUTION:

• Instance method invocations
• Object creation
• Object destruction

Which SOLID design principle does Aspect Oriented Programming primarily address?

Single Responsibility Principle.

Open-Closed Principle

Liskov Substitution Principle

Interface Segregation Principle

Dependency Inversion Principle

SOLUTION:

Single Responsibility Principle.